Struktur Data Bebas Kunci JavaScript SharedArrayBuffer: Operasi Atomik

Dalam ranah pengembangan web modern dan lingkungan JavaScript sisi server seperti Node.js, kebutuhan akan pemrograman konkuren yang efisien terus meningkat. Seiring aplikasi menjadi lebih kompleks dan menuntut kinerja yang lebih tinggi, para pengembang semakin mengeksplorasi teknik untuk memanfaatkan banyak inti dan utas. Salah satu alat yang kuat untuk mencapai ini di JavaScript adalah SharedArrayBuffer, yang dikombinasikan dengan operasi Atomics, yang memungkinkan pembuatan struktur data bebas kunci.

Pengenalan Konkurensi dalam JavaScript

Secara tradisional, JavaScript dikenal sebagai bahasa berutas tunggal. Ini berarti hanya satu tugas yang dapat dieksekusi pada satu waktu dalam konteks eksekusi tertentu. Meskipun ini menyederhanakan banyak aspek pengembangan, ini juga bisa menjadi penghambat untuk tugas-tugas yang intensif secara komputasi. Web Workers menyediakan cara untuk mengeksekusi kode JavaScript di utas latar belakang, tetapi komunikasi antar worker secara tradisional bersifat asinkron dan melibatkan penyalinan data.

SharedArrayBuffer mengubah ini dengan menyediakan wilayah memori yang dapat diakses oleh banyak utas secara bersamaan. Namun, akses bersama ini memperkenalkan potensi kondisi balapan (race conditions) dan korupsi data. Di sinilah Atomics berperan. Atomics menyediakan serangkaian operasi atomik yang menjamin bahwa operasi pada memori bersama dilakukan secara tak terpisahkan, mencegah korupsi data.

Memahami SharedArrayBuffer

SharedArrayBuffer adalah objek JavaScript yang merepresentasikan buffer data biner mentah dengan panjang tetap. Tidak seperti ArrayBuffer biasa, SharedArrayBuffer dapat dibagikan di antara beberapa utas (Web Workers) tanpa memerlukan penyalinan data secara eksplisit. Hal ini memungkinkan konkurensi memori bersama yang sejati.

Contoh: Membuat SharedArrayBuffer

            
const sab = new SharedArrayBuffer(1024); // SharedArrayBuffer 1KB

            

              
                Copy
              
            
          

Untuk mengakses data di dalam SharedArrayBuffer, Anda perlu membuat tampilan array bertipe, seperti Int32Array atau Float64Array:

            
const int32View = new Int32Array(sab);

            

              
                Copy
              
            
          

Ini menciptakan tampilan Int32Array di atas SharedArrayBuffer, memungkinkan Anda untuk membaca dan menulis integer 32-bit ke memori bersama.

Peran Atomics

Atomics adalah objek global yang menyediakan operasi atomik. Operasi ini menjamin bahwa pembacaan dan penulisan ke memori bersama dilakukan secara atomik, mencegah kondisi balapan. Mereka sangat penting untuk membangun struktur data bebas kunci yang dapat diakses dengan aman oleh banyak utas.

Operasi Atomik Kunci:

• Atomics.load(typedArray, index): Membaca nilai dari indeks yang ditentukan dalam array bertipe.
• Atomics.store(typedArray, index, value): Menulis nilai ke indeks yang ditentukan dalam array bertipe.
• Atomics.add(typedArray, index, value): Menambahkan nilai ke nilai pada indeks yang ditentukan.
• Atomics.sub(typedArray, index, value): Mengurangi nilai dari nilai pada indeks yang ditentukan.
• Atomics.exchange(typedArray, index, value): Mengganti nilai pada indeks yang ditentukan dengan nilai baru dan mengembalikan nilai asli.
• Atomics.compareExchange(typedArray, index, expectedValue, newValue): Membandingkan nilai pada indeks yang ditentukan dengan nilai yang diharapkan. Jika sama, nilai tersebut diganti dengan nilai baru. Mengembalikan nilai asli.
• Atomics.wait(typedArray, index, expectedValue, timeout): Menunggu nilai pada indeks yang ditentukan berubah dari nilai yang diharapkan.
• Atomics.wake(typedArray, index, count): Membangunkan sejumlah waiter yang ditentukan yang sedang menunggu nilai pada indeks yang ditentukan.

Operasi-operasi ini fundamental untuk membangun algoritma bebas kunci.

Membangun Struktur Data Bebas Kunci

Struktur data bebas kunci adalah struktur data yang dapat diakses oleh banyak utas secara bersamaan tanpa menggunakan kunci. Ini menghilangkan overhead dan potensi deadlock yang terkait dengan mekanisme penguncian tradisional. Menggunakan SharedArrayBuffer dan Atomics, kita dapat mengimplementasikan berbagai struktur data bebas kunci di JavaScript.

1. Penghitung Bebas Kunci

Contoh sederhana adalah penghitung bebas kunci. Penghitung ini dapat ditambah dan dikurangi oleh banyak utas tanpa kunci apa pun.

            
class LockFreeCounter {
  constructor() {
    this.buffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT);
    this.view = new Int32Array(this.buffer);
  }

  increment() {
    Atomics.add(this.view, 0, 1);
  }

  decrement() {
    Atomics.sub(this.view, 0, 1);
  }

  getValue() {
    return Atomics.load(this.view, 0);
  }
}

// Contoh penggunaan di dua web workers
const counter = new LockFreeCounter();

// Worker 1
for (let i = 0; i < 1000; i++) {
  counter.increment();
}

// Worker 2
for (let i = 0; i < 1000; i++) {
  counter.decrement();
}

// Setelah kedua worker selesai (menggunakan mekanisme seperti Promise.all untuk memastikan penyelesaian)
// counter.getValue() seharusnya mendekati 0. Hasil sebenarnya mungkin bervariasi karena konkurensi

            

              
                Copy
              
            
          

2. Tumpukan (Stack) Bebas Kunci

Contoh yang lebih kompleks adalah tumpukan bebas kunci. Tumpukan ini menggunakan struktur linked list yang disimpan di SharedArrayBuffer dan operasi atomik untuk mengelola penunjuk kepala (head pointer).

            
class LockFreeStack {
  constructor(capacity) {
    this.capacity = capacity;
    // Setiap node membutuhkan ruang untuk nilai dan penunjuk ke node berikutnya
    // Alokasikan ruang untuk node dan penunjuk kepala
    this.buffer = new SharedArrayBuffer((capacity + 1) * 2 * Int32Array.BYTES_PER_ELEMENT); // Nilai & penunjuk Berikutnya untuk setiap node + Penunjuk Kepala
    this.view = new Int32Array(this.buffer);

    this.headIndex = capacity * 2; // indeks di mana penunjuk kepala disimpan
    Atomics.store(this.view, this.headIndex, -1); // Inisialisasi kepala ke null (-1)

    // Inisialisasi node dengan penunjuk 'next' mereka untuk digunakan kembali nanti.
    for (let i = 0; i < capacity; i++) {
      const nextIndex = (i === capacity - 1) ? -1 : i + 1; // node terakhir menunjuk ke null
      this.setNext(i, nextIndex);
    }

    this.freeListHead = 0; // Inisialisasi kepala daftar bebas ke node pertama
  }

  setNext(nodeIndex, nextIndex) {
     this.view[nodeIndex * 2 + 1] = nextIndex;
  }

  getNext(nodeIndex) {
     return this.view[nodeIndex * 2 + 1];
  }

  getValue(nodeIndex) {
    return this.view[nodeIndex * 2];
  }

  setValue(nodeIndex, value){ 
      this.view[nodeIndex*2] = value;
  }

  push(value) {
    let nodeIndex = this.freeListHead; // coba ambil dari freeList
    if (nodeIndex === -1) {
      return false; // stack overflow
    }

    let nextFree = this.getNext(nodeIndex);
    // secara atomik coba perbarui kepala freeList ke nextFree. Jika gagal, orang lain sudah mengambilnya.
    if (Atomics.compareExchange(this.view, this.capacity*2, nodeIndex, nextFree) !== nodeIndex) {
        return false; // coba lagi jika ada perebutan
    }

    // kita punya node, tulis nilai ke dalamnya
    this.setValue(nodeIndex, value);

    let head;
    let newHead = nodeIndex;

    do {
      head = Atomics.load(this.view, this.headIndex);
      this.setNext(newHead, head);
      // Bandingkan-dan-tukar kepala dengan newHead. Jika gagal, berarti utas lain melakukan push di antaranya
    } while (Atomics.compareExchange(this.view, this.headIndex, head, newHead) !== head);

    return true; // berhasil
  }

  pop() {
    let head = Atomics.load(this.view, this.headIndex);
    if (head === -1) {
      return undefined; // tumpukan kosong
    }

    let next = this.getNext(head);
    // Coba perbarui kepala ke berikutnya. Jika gagal, berarti utas lain melakukan pop di antaranya
    if (Atomics.compareExchange(this.view, this.headIndex, head, next) !== head) {
      return undefined; // coba lagi, atau indikasikan kegagalan.
    }

    const value = this.getValue(head);

    // Kembalikan node ke freelist.
    let currentFreeListHead = this.freeListHead;
    do {
        this.setNext(head, currentFreeListHead); // arahkan node yang dibebaskan ke freelist saat ini
    } while(Atomics.compareExchange(this.view, this.capacity*2, currentFreeListHead, head) !== currentFreeListHead);

    return value; // berhasil
  }
}

// Contoh Penggunaan (di dalam worker):
const stack = new LockFreeStack(1024); // Buat tumpukan dengan 1024 elemen

//pushing
stack.push(10);
stack.push(20);

//popping
const value1 = stack.pop(); // Nilai 20
const value2 = stack.pop(); // Nilai 10


            

              
                Copy
              
            
          

3. Antrean (Queue) Bebas Kunci

Membangun antrean bebas kunci melibatkan pengelolaan penunjuk kepala (head) dan ekor (tail) secara atomik. Ini lebih kompleks daripada tumpukan tetapi mengikuti prinsip serupa menggunakan Atomics.compareExchange.

Catatan: Implementasi detail dari antrean bebas kunci akan lebih luas dan di luar cakupan pengenalan ini tetapi akan melibatkan konsep serupa seperti tumpukan, mengelola memori dengan hati-hati, dan menggunakan operasi CAS (Compare-and-Swap) untuk menjamin akses konkuren yang aman.

Manfaat Struktur Data Bebas Kunci

• Peningkatan Kinerja: Menghilangkan kunci mengurangi overhead dan menghindari perebutan, yang mengarah pada throughput yang lebih tinggi.
• Menghindari Deadlock: Algoritma bebas kunci secara inheren bebas dari deadlock karena tidak bergantung pada kunci.
• Peningkatan Konkurensi: Memungkinkan lebih banyak utas untuk mengakses struktur data secara bersamaan tanpa saling memblokir.

Tantangan dan Pertimbangan

• Kompleksitas: Mengimplementasikan algoritma bebas kunci bisa jadi rumit dan rawan kesalahan. Membutuhkan pemahaman mendalam tentang konkurensi dan model memori.
• Masalah ABA: Masalah ABA terjadi ketika sebuah nilai berubah dari A ke B dan kemudian kembali ke A. Operasi compare-and-swap mungkin berhasil secara tidak benar, yang menyebabkan korupsi data. Solusi untuk masalah ABA seringkali melibatkan penambahan penghitung ke nilai yang dibandingkan.
• Manajemen Memori: Manajemen memori yang cermat diperlukan untuk menghindari kebocoran memori dan memastikan alokasi dan dealokasi sumber daya yang tepat. Teknik seperti hazard pointers atau reklamasi berbasis zaman dapat digunakan.
• Debugging: Debugging kode konkuren bisa menjadi tantangan, karena masalah bisa sulit untuk direproduksi. Alat seperti debugger dan profiler dapat membantu.

Contoh Praktis dan Kasus Penggunaan

Struktur data bebas kunci dapat digunakan dalam berbagai skenario di mana konkurensi tinggi dan latensi rendah diperlukan:

• Pengembangan Game: Mengelola status game dan menyinkronkan data antara beberapa utas game.
• Sistem Real-time: Memproses aliran data dan peristiwa real-time.
• Server Berkinerja Tinggi: Menangani permintaan konkuren dan mengelola sumber daya bersama.
• Pemrosesan Data: Pemrosesan paralel kumpulan data besar.
• Aplikasi Keuangan: Melakukan perdagangan frekuensi tinggi dan perhitungan manajemen risiko.

Contoh: Pemrosesan Data Real-time dalam Aplikasi Keuangan

Bayangkan sebuah aplikasi keuangan yang memproses data pasar saham real-time. Beberapa utas perlu mengakses dan memperbarui struktur data bersama yang merepresentasikan harga saham, buku pesanan, dan posisi perdagangan. Dengan menggunakan struktur data bebas kunci, aplikasi dapat secara efisien menangani volume data masuk yang tinggi dan memastikan eksekusi perdagangan yang tepat waktu.

Kompatibilitas dan Keamanan Browser

SharedArrayBuffer dan Atomics didukung secara luas di browser modern. Namun, karena kekhawatiran keamanan terkait kerentanan Spectre dan Meltdown, browser pada awalnya menonaktifkan SharedArrayBuffer secara default. Untuk mengaktifkannya kembali, Anda biasanya perlu mengatur header respons HTTP berikut:

            
Cross-Origin-Embedder-Policy: require-corp
Cross-Origin-Opener-Policy: same-origin

            

              
                Copy
              
            
          

Header ini mengisolasi origin Anda, mencegah kebocoran informasi lintas-origin. Pastikan server Anda dikonfigurasi dengan benar untuk mengirim header ini saat menyajikan kode JavaScript yang menggunakan SharedArrayBuffer.

Alternatif untuk SharedArrayBuffer dan Atomics

Meskipun SharedArrayBuffer dan Atomics menyediakan alat yang kuat untuk pemrograman konkuren, pendekatan lain juga ada:

• Pengiriman Pesan (Message Passing): Menggunakan pengiriman pesan asinkron antara Web Workers. Ini adalah pendekatan yang lebih tradisional tetapi melibatkan penyalinan data antar utas.
• Utas WebAssembly (WASM): WebAssembly juga mendukung memori bersama dan operasi atomik, yang dapat digunakan untuk membangun aplikasi konkuren berkinerja tinggi.
• Service Workers: Meskipun terutama untuk caching dan tugas latar belakang, service workers juga dapat digunakan untuk pemrosesan konkuren menggunakan pengiriman pesan.

Pendekatan terbaik tergantung pada persyaratan spesifik aplikasi Anda. SharedArrayBuffer dan Atomics paling cocok ketika Anda perlu berbagi sejumlah besar data antar utas dengan overhead minimal dan sinkronisasi yang ketat.

Praktik Terbaik

• Jaga Tetap Sederhana: Mulailah dengan algoritma bebas kunci yang sederhana dan secara bertahap tingkatkan kompleksitasnya sesuai kebutuhan.
• Pengujian Menyeluruh: Uji kode konkuren Anda secara menyeluruh untuk mengidentifikasi dan memperbaiki kondisi balapan dan masalah konkurensi lainnya.
• Tinjauan Kode: Minta kode Anda ditinjau oleh pengembang berpengalaman yang akrab dengan pemrograman konkuren.
• Gunakan Profiling Kinerja: Gunakan alat profiling kinerja untuk mengidentifikasi bottleneck dan mengoptimalkan kode Anda.
• Dokumentasikan Kode Anda: Dokumentasikan kode Anda dengan jelas untuk menjelaskan desain dan implementasi algoritma bebas kunci Anda.

Kesimpulan

SharedArrayBuffer dan Atomics menyediakan mekanisme yang kuat untuk membangun struktur data bebas kunci di JavaScript, memungkinkan pemrograman konkuren yang efisien. Meskipun kompleksitas implementasi algoritma bebas kunci bisa menakutkan, potensi manfaat kinerjanya signifikan untuk aplikasi yang memerlukan konkurensi tinggi dan latensi rendah. Seiring JavaScript terus berkembang, alat-alat ini akan menjadi semakin penting untuk membangun aplikasi berkinerja tinggi dan skalabel. Merangkul teknik-teknik ini, bersama dengan pemahaman yang kuat tentang prinsip-prinsip konkurensi, memberdayakan pengembang untuk mendorong batas kinerja JavaScript di dunia multi-inti.

Sumber Belajar Lanjutan

• MDN Web Docs: SharedArrayBuffer
• MDN Web Docs: Atomics
• Makalah tentang struktur data dan algoritma bebas kunci.
• Postingan blog dan artikel tentang pemrograman konkuren di JavaScript.